%load_ext pretty_jupyter

import pandas as pd
import os
import numpy as np
import re
from sklearn.pipeline import Pipeline
from sklearn.base import BaseEstimator, TransformerMixin

ratings_treino = pd.read_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/2.Datasets_Limpeza/ratings_treino.pickle", compression="gzip")

ratings_teste = pd.read_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/2.Datasets_Limpeza/ratings_teste.pickle", compression="gzip")

ratings_treino

class EliminarColuna(BaseEstimator, TransformerMixin):
    def __init__(self, col_eliminar):
        self.col_eliminar = col_eliminar

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        X_transformado = X.drop(columns=self.col_eliminar)
        return X_transformado

class AvaliacoesFilme(BaseEstimator, TransformerMixin):
    ''' Classe que cria uma coluna com o total de avaliações por filme 
    Args:
    - coluna: nome da coluna com o número de ocorrências de cada valor (movieId)
    - X : nome da tabela (com dados de treino ou teste)

    '''
    def __init__(self, coluna):
        self.coluna = coluna

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        tabela_agrupada = X.groupby(self.coluna).size().reset_index(name="Numero_de_Avaliacoes_por_Filme")
        tabela_mesclada = pd.merge(tabela_agrupada, X, on=self.coluna)
        return tabela_mesclada

class AvaliacoesUsuarios(BaseEstimator, TransformerMixin):
    ''' Classe que cria uma coluna com o total de avaliações por usuários 
    Args:
    - coluna: nome da coluna com o número de ocorrências de cada valor (userId)
    - X : nome da tabela (com dados de treino ou teste)
    '''
    def __init__(self, coluna):
        self.coluna = coluna

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        tabela_agrupada = X.groupby(self.coluna).size().reset_index(name="Numero_de_Avaliacoes_por_usuarios")
        tabela_mesclada = pd.merge(tabela_agrupada, X, on=self.coluna)
        return tabela_mesclada 

class MediaSimples(BaseEstimator, TransformerMixin):
    def __init__(self, col_movie, col_rating):
        self.col_movie = col_movie
        self.col_rating = col_rating

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        df_media = X.groupby(self.col_movie)[self.col_rating].mean().reset_index()
        df_media1 = df_media.rename(columns={self.col_rating:'rating_medio_simples'})
        df_media_mesclado = pd.merge(X, df_media1, on=self.col_movie)
        return df_media_mesclado

class MediaPonderada(BaseEstimator, TransformerMixin):
    ''' Classe que cria uma coluna com o rating médio ponderado '''
    def __init__(self, col_avaliacoes_filmes , col_rating_medio_simples, penalizacao):
        self.col_avaliacoes_filmes = col_avaliacoes_filmes
        self.col_rating_medio_simples = col_rating_medio_simples
        self.penalizacao = penalizacao

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        fator_suavizacao = self.penalizacao
        X['log_numero_avaliacoes'] = np.log(X[self.col_avaliacoes_filmes]+1)
        X['rating_medio_ponderado'] = (X[self.col_avaliacoes_filmes]*X[self.col_rating_medio_simples]) / \
            (X[self.col_avaliacoes_filmes] + X['log_numero_avaliacoes'] * fator_suavizacao)
        X.drop(columns='log_numero_avaliacoes', inplace=True)
        return X

class MediaTimes(BaseEstimator, TransformerMixin):
    def __init__(self, current_date=None, decay_rate=0.0005):
        ''' Inicializando da Classe MediaTimes
        Args:
        - current_date: data atual
        - decay_rate: a taxa de decaimento exponencial (default é 0.0005).
        '''
        self.current_date = current_date if current_date else pd.to_datetime('today')
        self.decay_rate = decay_rate

    def fit(self, X, y=None):
        # Neste caso, fit não faz nada, pois não há parâmetros a aprender
        return self

    def transform(self, X, y=None):
        ''' Função que aplica a transformação em X
        Args:
        - X: DataFrame e contém as colunas 'rating' e 'timestamp'
        '''
        # Assumindo que X é um 
        X = X.copy()
        # Converter timestamp para datetime
        X['timestamp'] = pd.to_datetime(X['timestamp'], unit='s')  
        # Criar a nova coluna de rating ponderado
        X['rating_times'] = X.apply(lambda row: self.calculate_weighted_rating(row['rating'], row['timestamp']), axis=1)
        return X

    def calculate_weighted_rating(self, rating, date):
        ''' Função que calcula Calcula o rating ponderado
               com base na diferença em dias entre a data da avaliação 
               e a data atual. Ou seja, 
              - peso = e^(decay_rate * diferença dias)
              - Rating_Times = Rating * Peso
        '''
        # Calculando a diferença em dias
        days_diff = (self.current_date - date).days
        # Calculando o peso
        peso = np.exp(-self.decay_rate * days_diff)
        # Retornando o rating ponderado
        return rating * peso

# Criar a pipeline
pipeline_analise = Pipeline([
    ('eliminar_timestamp',EliminarColuna(col_eliminar='timestamp')),
    ('avaliacoes_filme', AvaliacoesFilme(coluna='movieId')),
    ('avaliacoes_usuarios', AvaliacoesUsuarios(coluna='userId')),
    ('media_simples', MediaSimples(col_movie='movieId', col_rating='rating')),
    ('media_ponderada', MediaPonderada(col_avaliacoes_filmes='Numero_de_Avaliacoes_por_Filme', 
                                        col_rating_medio_simples='rating_medio_simples', penalizacao=50))
])

pipeline_analise

pipeline_modelagem = Pipeline([
    ('rating vs times', MediaTimes()),
    ('avaliacoes_filme', AvaliacoesFilme(coluna='movieId')),
    ('avaliacoes_usuarios', AvaliacoesUsuarios(coluna='userId')),
    ('media_simples', MediaSimples(col_movie='movieId', col_rating='rating')),
    ('media_ponderada', MediaPonderada(col_avaliacoes_filmes='Numero_de_Avaliacoes_por_Filme', 
                                        col_rating_medio_simples='rating_medio_simples', penalizacao=50))
])

pipeline_modelagem

# Usar a pipeline
ratings_treino_transformado = pipeline_analise.fit_transform(ratings_treino)
ratings_teste_transformado = pipeline_analise.transform(ratings_teste)

ratings_treino_transformado

ratings_teste_transformado

# Usar a pipeline
ratings_treino_transformado_modelagem = pipeline_modelagem.fit_transform(ratings_treino)
ratings_teste_transformado_modelagem = pipeline_modelagem.transform(ratings_teste)

ratings_treino_transformado_modelagem 

ratings_teste_transformado_modelagem 

# Salvar tabela com dados de treino
#ratings_treino_transformado.to_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/3.Datasets_Transformação/3.1_Datasets_Transformação_parte_1/ratings_treino_transformado.pickle", compression = "gzip")
# Salvar tabela com dados de treino
ratings_treino_transformado_modelagem.to_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/3.Datasets_Transformação/3.1_Datasets_Transformação_parte_1/ratings_treino_transformado_modelagem.pickle", compression = "gzip")

# Salvar tabela com dados de teste
#ratings_teste_transformado.to_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/3.Datasets_Transformação/3.1_Datasets_Transformação_parte_1/ratings_teste_transformado.pickle", compression = "gzip")
# Salvar tabela com dados de teste
ratings_teste_transformado_modelagem.to_pickle("C:/0.Projetos/5.Sistema_de_Recomendacao_MovieLens_2/Datasets/3.Datasets_Transformação/3.1_Datasets_Transformação_parte_1/ratings_teste_transformado_modelagem.pickle", compression = "gzip")